package com.study.kt._01grammar._01basic

import java.util.*
import kotlin.Comparator

/**
 * set的使用与List相同，只是set集合不可重复
 */
fun main() {
    //testList()
    //testSortList()
    //testGroupList()
    //testMapList()
    testFilterList()
    testMinMaxList()
    //testJoinToString()
    //testMap()
}

//map集合定义与List相同，定义可变、不可变map
fun testMap() {
    //创建一个不可变map，接收的参数为二元组Pair它本身就是一个键值对的字典
    //to为Pair()的运算符重载
    val map1 = mapOf("a" to "aaa", "b" to "bbb", Pair("c", "ccc"))
    println(map1.get("a"))
    println(map1["b"])

    //创建可变map
    //mutableMapOf()

    //创建Java中的map
    //hashMapOf<>() -> HashMap
    //linkedMapOf<>() -> LinkedHashMap

    //map的遍历
    //1.foreach遍历
    println("使用entry遍历")
    for (entry in map1) {
        //entry对应键值对，与Java相同
        println("key=${entry.key}<==>value=${entry.value}")
    }
    println("直接获取键值对遍历")
    for ((key, value) in map1) {
        println("key=${key}<==>value=${value}")
    }
    println("遍历key")
    for (key in map1.keys) {
        println("key=$key")
    }
    println("遍历value")
    for (value in map1.values) {
        println("value=$value")
    }
    println("使用迭代器遍历")
    val iterator = map1.iterator()
    while (iterator.hasNext()) {
        val nextEntry = iterator.next()
        println("key=${nextEntry.key}<==>value=${nextEntry.value}")
    }
}

//List转为指定的字符串
fun testJoinToString() {
    val strList = arrayOf("a", "b", "c")
    //将上述List转换为 (a|b|c)的字符串
    val str = strList.joinToString(separator = "|", prefix = "(", postfix = ")")
    println(str)
}

//集合过滤 查找年龄大于30的女孩
fun testFilterList() {
    girls.filter { it.age > 30 }.forEach { println(it) }
}

//查找集合中年龄最大、最小的gril
fun testMinMaxList() {
    println("年龄最小的女孩为： ${girls.minByOrNull { it.age }}")
    println("年龄最大的女孩为： ${girls.maxByOrNull { it.age }}")
}

//集合的map函数：将一个函数映射为另一种函数
//将datas中的grils集合的名称打印出来
fun testMapList() {
    girls.map { it.name }.forEach { println(it) }
}


//集合分组
fun testGroupList() {
    val nameList = listOf("张三", "张天华", "孙钱", "王柳", "王天石", "赵八")
    //按照姓进行分组 在Java中要遍历集合比较繁琐
    val nameMap = nameList.groupBy {
        when {
            //返回一个map前面是分组条件，后面是map的key
            it.startsWith("张") -> "姓张"
            it.startsWith("王") -> "姓王"
            else -> "其他姓氏"
        }
    }
    println(nameMap)
}

//集合排序
fun testSortList() {
    //普通排序
    val strList = listOf("z", "a", "q")
    //正序
    println(strList.sorted())
    //倒序
    println(strList.sortedDescending())

    //String实现了Comparable接口所以可以直接排序，而对于自定义对象的排序就需要制定排序条件
    val compBeanList = arrayOf(
        CompBean("fauks", 90),
        CompBean("java", 23), CompBean("bob", 50)
    )
    //compBeanList.sorted() 编译报错，因为自定义Bean没有实现排序接口
    val sortedList = compBeanList.sortedBy { it.age } //指定按照年龄正序 也可以倒序
    for (compBean in sortedList) {
        println(compBean)
    }

    //自定义对象除了按照某个属性排序外，也可以自己指定排序规则
    //Comparator是kotlin的匿名对象，在使用时前面需要添加object
    //如果不使用匿名对象，就需要自己建立类实现Comparator接口
    val sortedWith = compBeanList.sortedWith(Comparator { o1, o2 ->
        val o1Age = o1.age
        val o2Age = o2.age
        //return o1Age - o2Age//正序
        o2Age - o1Age//倒序
    })

    for (compBean in sortedWith) {
        println(compBean)
    }
}

//自定义类进行排序
data class CompBean(var name: String, var age: Int)

fun testList() {
    //创建List方式一,泛型通过自动推断为String、Int、Any(Java中的Object)
    val list1 = listOf("slx", "fauks")
    println(list1.get(0))
    //类似数组取值方式，该方式为运算符重载
    println(list1[1])
    //修改  list1[0]="xx"-->这种修改方式是错误，通过listOf创建的集合只读，不可修改、添加
    val t = listOf("a")


    //创建可以修改的集合 -->读取和上述一致
    val list2 = mutableListOf(1, 2, 3)
    list2[0] = 1000
    list2.add(200)
    println(list2)

    //创建指定类型的集合
    //创建ArrayList
    val arrayList1 = arrayListOf("a", "b")
    //创建ArrayList
    val linkedList = LinkedList<String>()
    //创建Vector（线程安全的集合）
    val vector = Vector<String>()

    //集合遍历
    for (i in list2) {
        println(i)
    }
    for ((index, i) in list2.withIndex()) {

    }

    list2.forEach { println(it) }

    //集合过滤
    val listName = listOf("张三", "张老", "孙无", "王流")
    //找出所有姓张的
    val newNameList = listName.filter { it.startsWith("张") }
    println(newNameList)

    //去除角标为偶数的元素
    val oNameList = listName.filterIndexed { index, _ -> index % 2 == 0 }
    println("偶数集合：$oNameList")

    val listName2 = listOf("张无极", "张三丰", "孙无", "王流")

    //将listName、listName2所有姓张的放到新的集合中
    val newListName = mutableListOf<String>()
    listName.filterTo(newListName) { it.startsWith("张") }
    listName2.filterTo(newListName) { it.startsWith("张") }
    println(newListName)
}
